def plot_solution_utilization_without_d_max(self):
"""
Funkcja reprezentująca wykorzystanie stacji dokujących BEZ zasięgu ich działania
"""
fig = plt.figure(figsize=(16, 12))
ax = fig.add_subplot(111)
im = ax.imshow(self.__plt_utilisation_without_d_max,
origin='lower',
interpolation='None',
cmap='YlOrBr')
plt.xlabel('Pozycja osi X')
plt.ylabel('Pozycja osi Y')
plt.title(
'Wykorzystanie poszczególnych stacji dokujących bez ograniczeń odległościowych'
)
size = self.__plt_utilisation_without_d_max.shape
for (j,
i), label in np.ndenumerate(self.__plt_utilisation_without_d_max):
if int(label) != 0 and self.__plt_map[j][i]:
ax.text(i, j, int(label), ha='center', va='center')
plt.xticks(range(0, size[1]))
plt.yticks(range(0, size[0]))
fig.colorbar(im)
save_plot_to_file(
plt, 'Dystrybucja klientow do stacji dokujących BEZ ograniczenia ')
plt.show()
def __generate_plot_of_moves(self):
"""
Funkcja służąca do wygenerowania mapy wszystkich ruchów jakie miały miejsce podczas działania algorytmu
:return:
"""
if self.__client_map is None:
raise ValueError(
'Nie można wygenerować zmian stacji dokujących bez mapy klientów!'
)
x_size = self.__client_map.shape[1]
y_size = self.__client_map.shape[0]
fig, ax = plt.subplots()
im = plt.imshow(self.__client_map,
origin='lower',
interpolation='None',
cmap='viridis')
x_a_copy = self.__x_a_list
for itr in range(1, self.__iteration_count):
# Utwórz macierz ruchu i na jej podstawie narysuj strzałki
move = x_a_copy[itr] - x_a_copy[itr - 1]
pos_arrow_head = np.where(move == 1)
x_arrow_head = pos_arrow_head[0][0]
y_arrow_head = pos_arrow_head[1][0]
pos_arrow_begin = np.where(move == -1)
x_arrow_begin = pos_arrow_begin[0][0]
y_arrow_begin = pos_arrow_begin[1][0]
dx = x_arrow_head - x_arrow_begin
dy = y_arrow_head - y_arrow_begin
ax.annotate("",
xy=(0.5, 0.5),
xytext=(0, 0),
arrowprops=dict(arrowstyle="->"))
plt.arrow(x_arrow_begin,
y_arrow_begin,
dx,
dy,
color='white',
width=0.005,
length_includes_head=True,
head_width=0.1,
head_length=0.15)
plt.scatter(x_arrow_begin,
y_arrow_begin,
facecolors='none',
edgecolors='white')
# Zaznaczenie finalnej pozycji stacji dokujących
x_a = x_a_copy[self.__iteration_count - 1]
for x in range(0, x_size):
for y in range(0, y_size):
if x_a[x][y] == 1:
plt.plot(x, y, 'ro')
plt.xlabel('Pozycja osi Y')
plt.ylabel('Pozycja osi X')
title = 'Mapa przemieszczen podczas działania algorytmu'
plt.title(title)
plt.colorbar(im)
save_plot_to_file(plt, 'Mapa_przemieszczen_stacji_dokujacych')
plt.show()
def __plot_elems_in_nei(self):
""""
Wykres ilości przeszukanych elementów w sąsiedztwie w danej iteracji
"""
x = np.linspace(1,
self.__iteration_count,
self.__iteration_count,
endpoint=True)
plt.plot(x, self.__elems_in_nei_list, 'go')
if self.__connect_dots_on_plot:
plt.plot(x, self.__elems_in_nei_list, 'g')
plt.xlabel('Numer iteracji')
plt.ylabel('Ilość elementów przeszukanych w sąsiedztwie')
plt.title(
'Ilość elementów przeszukanych w sąsiedztwie w danej iteracji')
save_plot_to_file(plt, 'Ilosc_przeszukanych_elementow_w_sasiedztwie')
plt.show()
def __plot_elems_in_long_tabu(self):
"""
Generowanie wykresu ilości zabronień wynikająca z listy długoterminowej
"""
x = np.linspace(1,
self.__iteration_count,
self.__iteration_count,
endpoint=True)
plt.plot(x, self.__elems_in_long_tabu, 'co')
if self.__connect_dots_on_plot:
plt.plot(x, self.__elems_in_long_tabu, 'c')
plt.xlabel('Numer iteracji')
plt.ylabel('Ilość zabronień wynikająca z listy długoterminowej ')
plt.title(
'Ilość zabronień wynikająca z listy długoterminowej w danej iteracji'
)
save_plot_to_file(plt, 'Ilosc_zabronien_dlugoterminowej_tabo_list')
plt.show()
def __plot_av_long_cadence(self):
"""
Generowanie wykresu średniego wieku zabronien na liście Tabu długoterminowej
"""
x = np.linspace(1,
self.__iteration_count,
self.__iteration_count,
endpoint=True)
plt.plot(x, self.__av_long_cadence, 'mo')
if self.__connect_dots_on_plot:
plt.plot(x, self.__av_long_cadence, 'm')
plt.xlabel('Numer iteracji')
plt.ylabel('Średni wiek zabronienia długoterminowej listy tabu ')
plt.title(
'Średni wiek zabronienia długoterminowej listy tabu w danej iteracji'
)
save_plot_to_file(plt,
'Sredni_wiek_elementow_dlugoterminowej_tabo_list')
plt.show()
def __plot_Q_a(self):
"""
Funkcja reprezentująca wykres funkcji celu w danej iteracji
"""
fig = plt.figure()
x = np.linspace(1,
self.__iteration_count,
self.__iteration_count,
endpoint=True)
plt.plot(x, self.__Q_a_list, 'bo')
if self.__connect_dots_on_plot:
plt.plot(x, self.__Q_a_list)
plt.plot(self.__min_Q_a_pos + 1, self.__Q_a_list[self.__min_Q_a_pos],
'ro')
plt.xlabel('Numer iteracji')
plt.ylabel('Wartośc funkcji celu')
plt.title('Wykres wartości funkcji celu w danej iteracji')
save_plot_to_file(plt, 'Wartosc_funkcji')
plt.show()
def plot_map_barriers(_barrier_map: np.array):
"""
Funkcja do wyswietalnia mapy barier ograniczajacej ruch robotow.
Bariery rozumiemiemy jako pola bez mozliwosci ruchu robotów.
"""
fig = plt.figure(figsize=(16, 12))
ax = fig.add_subplot(111)
im = ax.imshow(_barrier_map,
origin='lower',
interpolation='None',
cmap='Purples')
plt.xlabel('Pozycja osi Y')
plt.ylabel('Pozycja osi X')
plt.title('Mapa rozmieszczenia barrier')
size = _barrier_map.shape
plt.xticks(range(0, size[1]))
plt.yticks(range(0, size[0]))
fig.colorbar(im)
save_plot_to_file(plt, 'barrier_map')
plt.show()
def generate_plot_of_telemetry(telemetry_data: Dict):
"""
Funkcja służy do utworzenia wykresu przedstawiającego dane zebrane przez telemetrię
"""
fig, ax = plt.subplots(figsize=(16, 9))
# Sortowanie według łacznego czasu wykonania
telemetry_data = dict(
sorted(telemetry_data.items(), key=lambda x: x[1], reverse=True))
name_of_function = telemetry_data.keys()
total_time = telemetry_data.values()
# Generowanie wykresu
y_pos = np.arange(len(name_of_function))
ax.barh(y_pos, total_time, align='center')
ax.set_yticks(y_pos)
ax.set_yticklabels(name_of_function)
ax.invert_yaxis() # labels read top-to-bottom
ax.set_xlabel('Łączny czas wykonania w sekundach')
ax.set_title('Czas wykonania poszczególnych funkcji algorytmu')
save_plot_to_file(plt, 'telemetria')
plt.show()
def __plot_tabu_list_elements(self):
"""
Funkcja służąca do generacji wykresu ilości elementów na liście Tabu
"""
tabu_list_elements = []
for tabu in self.__Tabu_list:
tabu_list_elements.append(np.count_nonzero(tabu))
fig = plt.figure()
x = np.linspace(1,
self.__iteration_count,
self.__iteration_count,
endpoint=True)
plt.plot(x, tabu_list_elements, 'bo')
if self.__connect_dots_on_plot:
plt.plot(x, tabu_list_elements)
plt.xlabel('Numer iteracji')
plt.ylabel('Ilość elementów na liście tabu')
plt.title('Ilość elementów na liście tabu w danej iteracji')
save_plot_to_file(plt, 'Ilosc_elementow_tabo_list')
plt.show()
def plot_av_dist_for_cell_with_given_cliens(self):
fig, ax = plt.subplots(figsize=(16, 9))
# Sortowanie według łacznego czasu wykonania
# sorted_l = dict(sorted(self.__av_distance_for_clients_cell.items(), key=lambda x: x[1], reverse=True))
sorted_l = self.__av_distance_for_clients_cell
clients_no = sorted_l.keys()
av_dist = sorted_l.values()
# Generowanie wykresu
y_pos = np.arange(len(clients_no))
ax.barh(y_pos, av_dist, align='center')
ax.set_yticks(y_pos)
ax.set_yticklabels(clients_no)
ax.invert_yaxis() # labels read top-to-bottom
ax.set_xlabel('Średnia odległość do najbliższej stacji dokującej')
ax.set_ylabel('Ilość klientów w danej komórce')
ax.set_title(
'Średnia odległość do najbliższej stacji dokującej w zależności od ilości klientów w danej komórce'
)
save_plot_to_file(plt, 'srednia_odleglosc_w_zal_od_ilosc_klientow')
plt.show()
def plot_clients_within_plt_zone(self):
"""
Funkcja służąca do reprezentacji graficznej obszaru obsługiwanego przez stacje dokujące
"""
fig = plt.figure(figsize=(16, 12))
ax = fig.add_subplot(111)
im = ax.imshow(self.__client_within_plt_zone,
origin='lower',
interpolation='None',
cmap='cool')
plt.xlabel('Pozycja osi X')
plt.ylabel('Pozycja osi Y')
plt.title('Zasięg działania stacji dokujących')
size = self.__client_within_plt_zone.shape
for (j, i), label in np.ndenumerate(self.__client_map):
if self.__plt_map[j][i]:
plt.plot(i, j, 'wo')
plt.xticks(range(0, size[1]))
plt.yticks(range(0, size[0]))
save_plot_to_file(plt, 'Zasieg dzialania stacji dokujących')
plt.show()
def plot_av_clients_at_given_range(self):
fig, ax = plt.subplots(figsize=(16, 9))
# Sortowanie według łacznego czasu wykonania
# sorted_l = dict(sorted(self.__av_clients_at_given_range.items(), key=lambda x: x[1], reverse=True))
sorted_l = self.__av_clients_at_given_range
dist = sorted_l.keys()
av_clients = sorted_l.values()
# Generowanie wykresu
y_pos = np.arange(len(dist))
ax.barh(y_pos, av_clients, align='center')
ax.set_yticks(y_pos)
ax.set_yticklabels(dist)
ax.invert_yaxis() # labels read top-to-bottom
ax.set_xlabel('Średnia liczba klientów w danej komórce')
ax.set_ylabel('Odległość do najbliższej stacji dokującej')
ax.set_title(
'Średnia ilość klientów w danej komórce w zależności od odległości do stacji dokującej'
)
save_plot_to_file(
plt,
'srednia_ilosc_klientow_w_danej_odleglosc_od_stacji_dokujacej')
plt.show()
def __plot_plt_map(self):
"""
Funkcja reprezentująca optymalne rozmieszczenie stacji dokujących
"""
if self.__client_map is None:
fig = plt.figure()
ax = fig.add_subplot(111)
x_a = self.__x_a_list[self.__min_Q_a_pos]
im = ax.imshow(x_a,
origin='lower',
interpolation='None',
cmap='Reds')
plt.xlabel('Pozycja osi Y')
plt.ylabel('Pozycja osi X')
plt.title('Optymalna pozycja stacji dokujących')
save_plot_to_file(plt, 'Optymalna_pozycja_stacji_dokujacych')
plt.show()
else:
fig = plt.figure()
ax = fig.add_subplot(111)
x_a = self.__x_a_list[self.__min_Q_a_pos]
im = ax.imshow(self.__client_map,
origin='lower',
interpolation='None',
cmap='viridis')
x_size = x_a.shape[0]
y_size = x_a.shape[1]
for x in range(0, x_size):
for y in range(0, y_size):
if x_a[x][y] == 1:
plt.plot(x, y, 'ro')
plt.xlabel('Pozycja osi Y')
plt.ylabel('Pozycja osi X')
plt.title('Optymalna pozycja stacji dokujących')
fig.colorbar(im)
save_plot_to_file(plt, 'Optymalna_pozycja_stacji_dokujacych')
plt.show()
def _plot_robots_movements(_robot_mov_list: np.array,
_barrier_map: np.array,
doc_station_map: np.array = None,
plot_name: str = 'przemieszczenie_robotow'):
"""
Funkcja służąca do wygenerowania mapy wszystkich ruchów jakie miały miejsce podczas przeprowadzania symulacji
Istnieje opcjoinalny parametr do naniesienia pozycji stacji dokujących
:return:
"""
barrier_map = copy(_barrier_map)
x_size = _barrier_map.shape[1]
y_size = _barrier_map.shape[0]
fig, ax = plt.subplots()
# Wyswietlanie mapy barrier
im = plt.imshow(_barrier_map,
origin='lower',
interpolation='None',
cmap='plasma')
(__iteration_count, robot_count, _) = _robot_mov_list.shape
# Petla iterujaca po poszczegolnych etapach symulacji
for itr in range(1, __iteration_count):
# petla po poszczegolnych robotach
for robot_id in range(robot_count):
pos_arrow_head = _robot_mov_list[itr, robot_id, :]
x_arrow_head = pos_arrow_head[1]
y_arrow_head = pos_arrow_head[0]
# Znajdz poorzednia pozycje danego robota
pos_arrow_begin = _robot_mov_list[itr - 1, robot_id, :]
x_arrow_begin = pos_arrow_begin[1]
y_arrow_begin = pos_arrow_begin[0]
dx = x_arrow_head - x_arrow_begin
dy = y_arrow_head - y_arrow_begin
ax.annotate("",
xy=(0.5, 0.5),
xytext=(0, 0),
arrowprops=dict(arrowstyle="->"))
plt.arrow(x_arrow_begin,
y_arrow_begin,
dx,
dy,
color='white',
width=0.005,
length_includes_head=True,
head_width=0.1,
head_length=0.15)
plt.scatter(x_arrow_begin,
y_arrow_begin,
facecolors='none',
edgecolors='white')
# Zaznaczenie finalnej pozycji stacji dokujących
if doc_station_map is not None:
for x in range(0, x_size):
for y in range(0, y_size):
if doc_station_map[x][y] != 0:
plt.plot(y, x, 'ro')
plt.xlabel('Pozycja osi Y')
plt.ylabel('Pozycja osi X')
title = 'Mapa przemieszczen robotow podczas działania algorytmu'
plt.title(title)
plt.colorbar(im)
save_plot_to_file(plt, plot_name)
plt.show()
def plot_client_map(_client_map: np.array,
max_clients_number_in_cell: int,
generate_3D_rotate_GIF: bool = False,
generate_2D: bool = False):
"""
:param client_map: Mapa rozmieszczenia klientów
:param max_clients_number_in_cell: Maksymalna ilość klientów jaka może byc w danej komórce
:param generate_3D_rotate_GIF: Parametr służący do utworzenia animowanego modelu mapy klientów
:param generate_2D: Parametr służący do reprezentacji mapy klientów w postaci 2D
:return:
"""
client_map = np.copy(_client_map)
data = setting_menager.get_plot_client_map_settings()
generate_3D_rotate_GIF = data['generate_3D_rotate_GIF']
generate_2D = data['generate_2D']
save_to_gif = data['save_to_gif']
if generate_2D:
fig = plt.figure(figsize=(16, 12))
ax = fig.add_subplot(111)
im = ax.imshow(client_map,
origin='lower',
interpolation='None',
cmap='Reds')
plt.xlabel('Pozycja osi Y')
plt.ylabel('Pozycja osi X')
plt.title('Ilość klientów w danym miejscu')
size = client_map.shape
for (j, i), label in np.ndenumerate(client_map):
ax.text(j, i, label, ha='center', va='center')
plt.xticks(range(0, size[1]))
plt.yticks(range(0, size[0]))
fig.colorbar(im)
save_plot_to_file(plt, 'client_map')
plt.show()
else:
x_size = 0.5
y_size = 0.5
fig = plt.figure()
ax = plt.axes(projection="3d")
map_size = client_map.shape
cmap = cm.get_cmap('viridis', max_clients_number_in_cell)
for x in range(0, map_size[0]):
for y in range(0, map_size[1]):
ax.bar3d(x,
y,
0,
x_size,
y_size,
client_map[x][y],
color=cmap.colors[client_map[x][y]])
plt.gca().invert_xaxis()
plt.title('Rozmieszczenie klientów na mapie')
ax.set_xlabel('Pozycja X')
ax.set_ylabel('Pozycja Y')
ax.set_zlabel('Ilość klientów na \ndanym obszarze')
save_plot_to_file(plt, 'client_map')
plt.show()
if generate_3D_rotate_GIF:
def animate(i):
ax.view_init(elev=10., azim=i)
return fig,
# Utwórz animację na podstawie mapy
anim = animation.FuncAnimation(fig,
animate,
frames=360,
interval=20,
blit=True)
# Zapisz animację do pliku pod formatem GIF
if save_to_gif:
save_anim_to_file(anim, 'client_map.gif')
else:
save_anim_to_file(anim, 'client_map.mp4')